// 题目描述
// 某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。

// 输入描述
// 第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。
// 后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。

// 输出描述
// 输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。 
// 如果不能成功处理（相互依赖），则输出 -1。

// 输入示例
// 5 4
// 0 1
// 0 2
// 1 3
// 2 4

// 输出示例
// 0 1 2 3 4
// 还存在
// 0 2 4 1 3
// 0 2 1 3 4
// 等等合法的顺序。


const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

void async function () {
    line = await readline()
    let [m, n] = line.split(" ").map(Number),
        // 每个节点的入度数组
        degree = new Array(m).fill(0),
        // 当前入度为0的还没有进入排序的节点
        zeroDegreeQueue = [],
        // 已经排序完成的节点
        result = [],
        // 各节点的依赖关系
        relyMap = new Map();

    while (line = await readline()) {
        let [left, right] = line.split(" ").map(Number);
        // 若有依赖，节点入度+1
        degree[right]++
        // 维护依赖左节点的右节点，当左节点移出时，依赖左节点的节点入度-1
        relyMap.get(left) ? relyMap.get(left).push(right) : relyMap.set(left, [right])
    }

    // 初始化zeroDegreeQueue,将入度为0的头结点放入队列
    for (let i = 0; i < m; i++) {
        if (degree[i] === 0) {
            zeroDegreeQueue.push(degree[i])
        }
    }

    while (zeroDegreeQueue.length > 0) {
        // 节点离开树，放入排序数组result
        let zeroDegreeNode = zeroDegreeQueue.shift(),
            rightRelyArr = relyMap.get(zeroDegreeNode) || [];
        result.push(zeroDegreeNode);

        // 依赖此节点的节点入度-1
        for (let rightRelyVal of rightRelyArr) {
            degree[rightRelyVal]--
            // 如果此时节点入度为0，加入队列,准备离开树
            if (degree[rightRelyVal] === 0) {
                zeroDegreeQueue.push(rightRelyVal)
            }
        }
    }

    // 如果节点有环,则result数组的长度会比节点的长度短。因为有环的时候，没有节点的入度为0
    console.log(result.length === m ? result.join(" ") : -1)

}()